\documentclass{classrep}
\usepackage[utf8]{inputenc}
\usepackage{color}
\usepackage{graphicx}
\usepackage{listings}
\usepackage[usenames,dvipsnames]{xcolor}
\usepackage{amssymb, amsmath}

\lstset{
  language=Java,
  numbers=left,
  frame=single,
  basicstyle=\footnotesize,
  captionpos=b,
  showspaces=false,
  showstringspaces=false,
}

\studycycle{Informatyka, studia dzienne, II st.}
\coursesemester{II}

\coursename{Komputerowe systemy rozpoznawania}
\courseyear{2012/2013}

\courseteacher{dr hab. inż. Adam Niewiadomski profesor PŁ}
\coursegroup{poniedziałek, 12:15}

\author{
  \studentinfo{Łukasz Kucharczyk}{170404} \and
  \studentinfo{Adam Taciak}{170405}
}

\title{Zadanie 2: Lingwistyczne podsumowania baz danych na zbiorach rozmytych typu 2}
\svnurl{http://code.google.com/p/kuznia-kodu/source/browse/trunk/ksr2/}

\begin{document}
\maketitle


\section{Cel}
Celem drugiego projektu, było przygotowanie aplikacji umożliwiającej generowanie podsumowań lingwistycznych dla relacyjnych baz danych.
Realizacja zdania, była podzielona na trzy etapy: wybór i przygotowanie bazy danych, stworzenie biblioteki umożliwiającej przeprowadzanie
podsumowań lingwistycznych oraz napisanie aplikacji która w przyjazny dla użytkownika sposób, umożliwiać będzie generowanie podsumowań.
Co ważne, aplikację powinna potrafić obsłużyć osoba która nigdy nie miała styczności z podsumowaniami lingwistycznymi, a co za tym idzie
aplikacj powinna dostarczać zdefiniowane przez eksperta cechy które użytkownik będzie mógł jedynie podsumować.


\section{Wprowadzenie}

%--------------------------------------- from previous doc
\subsubsection{Zbiór klasyczny} 
Zbiór klasyczny zdefiniowany jest jako funkcja określająca czy dany element należy do zbioru (1), czy nie (0). Badany element należy do pewnej przestrzeni rozważań. Wyróżniamy dyskretną oraz gęstą przestrzeń rozważań. Dyskretna przestrzeń to zbiór konkretnych elementów (np.: (0,1,2,3,4,5,6,7,8,9)), natomiast gęsta przestrzeń to zbiór elementów znajdujących się w pewnym przedziale (np.: $<0;9>$).\\

Funkcja charakterystyczna jest to funkcja przyjmująca 1, jeśli dany element należy do zbioru, 0 w przeciwnym wypadku. \\

Dopełnieni (uzupełnienie) zbioru jest to zbiór wszystkich elementów, które do danego zbioru nie należą:
\begin{center}
$ A \setminus  U = \{x \in A : x \not\in U \} $
\end{center}

Suma zbiorów jest to zbiór złożony ze wszystkich elementów należących do sumowanych zbiorów:
\begin{center}
$ A \cup B = \{ x:x\in A \vee x \in B \} $
\end{center}

Iloczyn zbiorów (część wspólna) to zbiór złożony z tych elementów, które jednocześnie należą do obu zbiorów:
\begin{center}
$ A \cap B = \{ x:x \in A \wedge x \in B \}$
\end{center}

\begin{flushleft}
Oznaczenia:\\
A, B - zbiór elementów \textit{x}\\
U - podzbiór zbioru A ($U\subseteq A$)\\
\end{flushleft}

\subsubsection{Zbiór rozmyty} 
Zbiorem rozmytym A w przestrzeni rozważań X definiujemy następująco:
\begin{center}
$ A = \{ x, \mu _A(x) > :x \in X \} $
\end{center}
gdzie $\mu _A(x)\rightarrow [0,1]$ jest funkcją przynależności.\\

Funkcja przynależności określa w jakim stopniu element należy do zbioru rozmytego.\\
Funkcja przynależności trójkątna (rysunek \ref{rys01}).\\
\begin{center}
$\mu_A(x;a,b,c) \Bigg\{ $
\begin{tabular}{ll}
0 & $x \leq a$ \\
$ \frac{x-a}{b-a} $ & $a < x \leq b$ \\
$ \frac{c-x}{c-b} $ & $b < x \leq c$ \\
0 & $x>c$ \\
\end{tabular}

\end{center}

\begin{figure}[ht]
		\begin{center}
			\includegraphics[width=80mm]{im/trojkat.jpg}
			\caption{Wykresy funkcji przynależności trójkątnej}
			\label{rys01} 
		\end{center}
\end{figure}
\begin{flushleft}
Funkcja przynależności trapezoidalna (rysunek \ref{rys02}).\\
\end{flushleft}
\begin{center}
$\mu_A(x;a,b,c,d) \Bigg\{ $
\begin{tabular}{ll}
0 & $x \leq a$ \\
$ \frac{x-a}{b-a} $ & $a < x \leq b$ \\
1 & $b < x \leq c$ \\
$ \frac{c-x}{c-b} $ & $b < x \leq c$ \\
0 & $x>c$ \\
\end{tabular}
\end{center}

\begin{figure}[ht]
		\begin{center}
			\includegraphics[width=80mm]{im/trapez.jpg}
			\caption{Wykresy funkcji przynależności trapezoidalnej}
			\label{rys02} 
		\end{center}
\end{figure}

Dopełnienie zbioru rozmytego A w przestrzeni rozważań X może być zdefiniowane jako zbiór rozmyty $A^c$ w przestrzeni rozważań X, którego funkcja przynależności zdefiniowano:
\begin{center}
$ \mu _{A^c} (x) = 1 - \mu _A (x) $
\end{center}

Sumą zbiorów rozmytych A i B w przestrzeni rozważań X definiujemy jako zbiór rozmyty w przestrzeni rozważań X, z funkcją przynależności:
\begin{center}
$ \mu _{A \cup B} (x) = max\{ \mu _A (x), \mu _B (x) \}$
\end{center}

Iloczynem zbiorów rozmytych A i B w przestrzeni rozważań X definiujemy jako zbiór rozmyty w przestrzeni rozważań X, z funkcją przynależności:
\begin{center}
$ \mu _{A \cap B} (x) = min\{ \mu _A (x), \mu _B (x) \}$
\end{center}

Nośnikiem zbioru rozmytego (support) A nazywamy zbiór klasyczny, zdefiniowany:
\begin{center}
$ supp(A) = \{ x \in X: \mu _A (x)>0 \} $
\end{center}
Zbiór rozmyty jest skończony/nieskończony wtedy i tylko wtedy, gdy jego nośnik jest skończony/nieskończony. Zbiór rozmyty jest policzalny/niepoliczalny wtedy i tylko wtedy, gdy jego nośnik jest policzalny/niepoliczalny.\\

Alfa przekrój zbioru rozmytego zawiera wszystkie elementy, których funkcja przynależności jest większa lub równa współczynnikowi alfa. Funkcja charakterystyczna alfa przekroju przyjmuje postać:
\begin{center}
$ \xi _{A_\alpha } (x) = \Big\{$ 
\begin{tabular}{ll}
1 & $\mu _A (x) > \alpha $\\
0 & w przeciwnym wypadku \\
\end{tabular}
,$x \in X$
\end{center}

Kardynalność zbiorów rozmytych w skończonej przestrzeni rozważań definiuje się jako:
\begin{center}
$ |A| = \sum_{} - count(A) = \sum\limits_{x\in X} \mu _A (x) $
\end{center}

Pusty zbiór rozmyty jest to zbiór, do którego nie należy żaden element z przestrzeni rozważań X:
\begin{center}
$ \not 0 = \{ <x,0>:x \in X \}$
\end{center}

Zbiór rozmyty A w przestrzeni rozważań X jest wypukły jeśli dla każdego jego alfa przekroju spełniona jest zależność:
\begin{center}
$ \forall _{a, s \in A_{\alpha}} \forall _{\lambda \in [0,1]} \lambda a + (1 - \lambda)s \in A_\alpha $
\end{center}

Zbiór rozmyty nazywamy normalnym, jeżeli istnieje co najmniej jeden element $x \in X$ taki, że $ \mu_A(x) = 1$.\\

Wysokości zbioru rozmytego A nazywamy największy stopień przynależności elementu $x \in X$. 
\begin{center}
$ height(A) =$ max $\mu_A(x) $
\end{center}

Jądrem zbioru rozmytego A nazywamy zbiór takich elementów x, których wartość funkcji przynależności jest równa 1:
\begin{center}
$ core(A) = \{ x:\mu_A(x)=1 \wedge x \in X \} $
\end{center}

\subsubsection{Operacje na zbiorach rozmytych wg różnych norm trójkątnych} 
Sumowanie dwóch zbiorów rozmytych realizuje się przy pomocy s-normy. Operator S
\begin{center}
$ S:[0,1] \times [0, 1] \rightarrow [0,1] $
\end{center}
nazywamy s-normą, jeżeli spełnione są warunki:
\begin{itemize}
\item $S(a, b) = S(b, a)$ (przemienność)
\item $S(a,S(b, c)) = S(S(a, b), c)$ (łączność)
\item $S(a, b) > S(c, d)$ dla $a > c, b > d$ (monotoniczność)
\item $S(a, 0) = a$ (tożsamość zera)
\end{itemize}
Typowe operatory sumowania:
\begin{itemize}
\item Maksimum\\
$ \mu_{A\cup B} =$ max $( \mu_A(x), \mu_B(x) )$
\item Suma algebraiczna\\
$ \mu_{A\cup B} = \mu_A(x) + \mu_B(x) - \mu_A(x)\mu_B(x) $
\end{itemize}

Iloczyn dwóch zbiorów rozmytych realizuje się przy pomocy T-normy. Operator T
\begin{center}
$ T:[0,1] \times [0, 1] \rightarrow [0,1] $
\end{center}
nazywamy s-normą, jeżeli spełnione są warunki:
\begin{itemize}
\item $T(a, b) = T(b, a)$ (przemienność)
\item $T(a,S(b, c)) = T(T(a, b), c)$ (łączność)
\item $T(a, b) > T(c, d)$ dla $a > c, b > d$ (monotoniczność)
\item $T(a, 1) = a$ (tożsamość zera)
\end{itemize}
Typowe operatory iloczynu:
\begin{itemize}
\item Minimum\\
$ \mu_{A\cup B} =$min $( \mu_A(x), \mu_B(x) )$
\item Iloczyn\\
$ \mu_{A\cap B} = \mu_A(x)\mu_B(x) $
\end{itemize}

\subsubsection{Zmienna lingwistyczna} 
Zmienna lingwistyczna L jest uporządkowaną piątką o następującej postaci:
\begin{center}
$L = <L, H, X, G, K>$
\end{center}
gdzie:
\begin{itemize}
\item L – nazwa zmiennej lingwistycznej (np. wiek)
\item H lub H(L) – zbiór wartości (etykiet) zmiennej lingwistycznej L (np. zbiór: młody, nowicjusz, w średnim wieku, doświadczony, stary)
\item X - przestrzeń rozważań
\item G - syntaktyczna reguła, która generuje etykiety dla zmiennej L (czyli np. zbiór: młody, nowicjusz, w średnim wieku itd.)
\item K – semantyczna reguła, która wiąże ze sobą etykiety H(L) ze zbiorami rozmytymi w X
\end{itemize}

\subsubsection{Kwantyfikatory lingwistyczne} 
Dwie formy ilościowych wyrażeń lingwistycznych:
\begin{center}
\textit {Q obiektów jest $S_1$}\\
\textit {Q obiektów będących $S_2$ jest $S_1$}\\
\end{center}
gdzie:
$S_1$, $S_2$ - etykiety powiązane ze zbiorem rozmytym w przestrzeni rozważań X\\
Q - ilościowe wyrażenie lingwistyczne\\

Kwantyfikator bezwzględny (absolutny) reprezentowany jest przez zbiór rozmyty w przestrzeni $X\subseteq R^+ \cup \{0\}$.\\

Kwantyfikator względny (relative) reprezentowany jest przez zbiór rozmyty na przedziale [0, 1] jako przestrzeni rozważań oraz wyraża ilość będącą przedmiotem zainteresowania jako stosunek/współczynnik.

\subsubsection{Zbiór rozmyty typu 2} 
Zbiór rozmyty typu 2 $\tilde{A}$ opisany w przestrzeni rozważań X definiujemy następująco:
\begin{center}
$ \tilde{A} = \{ <x, \mu_{\tilde{A}(x)}>:x \in X \}$
\end{center}
gdzie: $\mu_{\tilde{A}} : X \rightarrow F([0,1])$ jest funkcją przynależności drugiego typu zbioru rozmytego typu 2 $\tilde{A}$ w przestrzeni rozważań X, gdzie F([0,1]) określa zbiór wszystkich zbiorów	rozmytych typu 1 w przedziale [0,1].\\

Zbiór rozmyty typu 2 $\tilde{A}$ w przestrzeni rozważań X jest normalny jeżeli spełnia warunek:
\begin{center}
$\exists _{x' \in X} u_{\tilde{A}} = 1 \wedge \mu_{x'}(u_{\tilde{A}}=1)=1$ , $u_{\tilde{A}} \in J_{x'}$\\
\end{center}

Nośnik zbioru rozmytego typu 2 $\tilde{A}$ w przestrzeni rozważań X definiowany jest:
\begin{center}
$ supp(\tilde{A}) = \{ < x, \mu_{supp(\tilde{A})}(x)>:x \in X \} $\\
$ \mu_{supp(\tilde{A})}(x) = sup_{u \in J_x \ \{0\}} \mu_x(u) $
\end{center}

Dopełnienie zbioru rozmytego typu 2 $\tilde{A}$ w przestrzeni rozważań X oznaczane jest jako $\tilde{A^c}$ i definiowane jest z funkcją przynależności:
\begin{center}
$ \mu_{\tilde{A^c}} = \int\limits_{\mu_{\tilde{A}} \in J_{x}} \mu_x(\mu_{\tilde{A}}) / (1 - \mu_{\tilde{A}}) $\\
\end{center}

Sumą zbiorów rozmytych typu 2 $\tilde{A}$ i $\tilde{B}$ w przestrzeni rozważań X oznaczanym jako $\tilde{A} \cup \tilde{B}$.Funkcja przynależności typu 2 $\mu_{\tilde{A}\cup \tilde{B}}$ jest zdefiniowana w warunkach operacji złączenia (join):
\begin{center}
$\mu_{\tilde{A}\cup \tilde{B}}(x) = \mu_{\tilde{A}}(x)\sqcup \mu_{\tilde{B}(x)} = \int\limits_{u_{\tilde{A}}} \int\limits_{u_{\tilde{B}}} (\mu_x(u_{\tilde{A}})t\mu_{x}(u_{\tilde{B}})) / (u_{\tilde{A}}su_{\tilde{B}})$
\end{center}
gdzie: t jest t-normą, s jest s-normą, $u_{\tilde{A}}, u_{\tilde{B}}$ to podstawowe stopnie przynależności.\\

Iloczyn zbiorów rozmytych typu 2 $\tilde{A}$ i $\tilde{B}$ w przestrzeni rozważań X oznaczamy jako $\tilde{A} \cap \tilde{B}$. Funkcja przynależności typu 2 $\mu_{\tilde{A} \cap \tilde{B}}$ jest zdefiniowana w warunkach operacji spotkania (meet):
\begin{center}
$\mu_{\tilde{A}\cap \tilde{B}}(x) = \mu_{\tilde{A}}(x)\sqcap \mu_{\tilde{B}(x)} = \int\limits_{u_{\tilde{A}}} \int\limits_{u_{\tilde{B}}} (\mu_x(u_{\tilde{A}})t\mu_{x}(u_{\tilde{B}})) / (u_{\tilde{A}}tu_{\tilde{B}})$
\end{center}
gdzie: t jest t-normą, $u_{\tilde{A}}, u_{\tilde{B}}$ to podstawowe stopnie przynależności.\\
%----------------------------------------------------------

Liczbę wszystkich możliwych podsumowań lingwistycznych definiuje poniższy wzór, gdzie $z$ jest liczbą wybranch cech do podsumowania:
\begin{equation}
  k \sum^{z-1}_{i=0} \binom{z}{i} (2^{z-1}-1)
  \label{wzor_generatora_podsumowan}
\end{equation}


\subsection{Baza danych}
Do realizcji pierwszego etapu zadania, czyli przygotowania bazy danych wykorzystano bazę SQLite, natomiast dane które są w niej przechowywane
to statystyki meczów NBA. Dane zostały pobrane ze strony internetowej Entertainment and Sports Programming Network (amerykańskiej
stacji telewizyjnej poświęconej tematyce sportowej) \textit{http://espn.go.com/nba/players}.
Zaletą bazy SQLite jest jej przenośność, cała baza danych przechowywana jest w jednym pliku, nie ma więc potrzeby instalacji dodatkowych
narzędzi jak np w: PostreSQL czy MySQL.

Analizowana baza danych przechowuje 23067 rekordów opisujących mecze 270 graczy NBA w sezonie 2010 - 2011. Dane dotyczące kolejnych
rozgrywek opisane są 18 atrybutami (wartościami numerycznymi) które nadają się do wykonania podsumowań lingwistycznych.

Poniższa lista zawiera wyjaśnienia danych w tabeli games.
\begin{itemize}
  \item min: ilość minut które zawodnik spędził w grze.
  \item fgm: ilość zdobytych punktów przy rzutach z pola gry.
  \item fga: ilość prób wykonania rzutów z pola gry.
  \item fgp: procentowy stosunek prób do udanych rzutów.
  \item 3pm: ilość wykonanych rzutów za 3 punkty w trakcie meczu.
  \item 3pa: ilość prób wykonania rzutów za 3 punkty w trakcie meczu.
  \item 3pp: procentowy stosunek prób do utanych rzutów za 3 punkty.
  \item ftm: ilość wykonanych rzutów osobistych w trakcie meczu.
  \item fta: ilość prób wykonania rzutów osobistych w trakcie meczu.
  \item ftp: procetowy stosunek prób do wykonanych rzutów osobistych.
  \item reb: ilość zbiórek\footnote{Zbiórka - złapanie piłki przez zawodnika drużyny broniącej lub atakującej po nieudanym rzucie do kosza.} wykonanych przez zawodnika w trakcie meczy.
  \item ast: liczba asyst wykonanych przez zawodnika w trakcie meczu.
  \item blk: liczba bloków wykonana przez zawodnika w trakcie meczu.
  \item stl liczba przejęć piłki przez zawodnika w trakcie meczu.
  \item pf: liczba fauli popełnionych przez gracza w trakcie meczu.
  \item to: liczba przyjęć z błędnych podań gracza z przeciwnej drużyny.
  \item pts: liczba punktów zdobyta przez zawodnika w trakcie meczu.
\end{itemize}


\section{Opis implementacji}

\subsection{Przestrzenie rozważań}
W aplikacji zaimplementowano obsługę przestrzeni rozważań gęstej oraz dyskretnej. Implementacje znajdują się kolejno
w klasach \textbf{Dense} oraz \textbf{Discrete}. Obie klasy implementują wspólny interfejs
\textbf{IUniverseOfDiscourse}.

Wspomniany interfejs wymaga implementacji następujących metod:
\begin{itemize}
  \item getElements -- metoda powinna zwracać listę elementów znajdujących się w przestrzeni rozważań.
  \item isExists -- metoda powinna zwracać wartość boolowską w zależności od tego, czy podany parametr wejściowy znajduje się w przestrzeni rozważań.
  \item getMinBoundary -- metoda powinna zwracać minimalną wartość w przestrzeni rozważań (jej lewą granicę).
  \item getMaxBoundary -- metoda powinna zwracać maksymalną wartość w przestrzeni rozważań (jej prawą granicę).
\end{itemize}

Dodatkwo dostarcza listę enumeracyjną używaną do definicji rodzaju przestrzeni rozważań (DENSE lub DISCRETE).

Dyskretną przestrzeń rozważań należy definiować przy użyciu metody \textbf{addElement} gdzie parametrem
wejściowym jest element który powinien znaleźć się w przestrzeni.

\begin{lstlisting}
Discrete universe = new Discrete();
universe.addElement(2.0);
universe.addElement(4.0);
universe.addElement(6.0);
\end{lstlisting}

Gęstą przestrzeń rozważań należy definiować przy użyciu metody \textbf{addInterval} gdzie parametrami wejściowymi 
jest przedział przestrzeni. Przedział można również zdefiniować od razu w konstruktorze klasy Dense.

\begin{lstlisting}
Dense universe1 = new Dense();
universe1.addInterval(0.0, 1,0);
Dense universe2 = new Dense(0.0, 1.0);
\end{lstlisting}

Z technicznego pnktu widzenia, elementy przestrzeni rozważań obu klas przechowywane są w identyczny sposób.
Obiekt klasy \textbf{TreeSet} przechowuje wszystkie elementy. Konieczne jest jeszcze dodanie iż gęsta
przestrzeń rozważań generowana jest na dyskretną przestrzeń rozważań. Definiując gęstą przestrzeń rozważań
o przedziale [0.0, 1.0] w klasie zapisane zostaną kolejne elementy z podanego przedziału z pewnym krokiem
(zdefiniowanym w konfiguracji aplikacji).

Przykładowo definiując przdział [0.0, 1.0] w klasie zostaną zpisane wartości: 0.00, 0.001, 0.002, 0.003, ..., 0.999, 1.000. Tak więc w rzeczywistości gęsta przestrzeń rozważań przechowywana jest identycznie jak dyskretna.

\subsection{Zbiory klasyczne}
Zbiory klasyczne reprezentowane są przez klasę \textbf{ClassicalSet} z pakietu \textbf{sets}. Klasa ta implementuje podstawe operacje
na zbiorach klasycznych jak: suma, iloczyn oraz dopełnienie. Wartość funkcji charakterystycznej zbioru obliczana jest
przez metodę \textbf{characteristicFunction}, gdzie na wejście podawana jest wartość dla której obliczona będzie wartość.
Zwracana wartość jest typu boolean. Dodatkowo na potrzeby testowania aplikacji powstała metoda \textbf{show} która wyświetla na ekranie
elemeny znajdujące się w przestrzeni rozważań.

\begin{lstlisting}
Dense universe = new Dense(1.0, 10.0);
ClassicalSet set = new ClassicalSet();

set.setUniverse(set);
set.characteristicFunction(2.3);
\end{lstlisting}

Poniżej znajduje się przykładowe wywołanie metod \textbf{intersection} oraz \textbf{union} które jako parametr wejściowy przyjmują
zbiór klasyczny (obiekt klasy \textbf{ClassicalSet}). Obiektem zwracanym jest nowy zbiór klasyczny, również obiekt klasy \textbf{ClassicalSet},
z przeliczoną przestrzenią rozważań.

\begin{lstlisting}
Dense u1 = new Dense(2.0, 6.0);
Dense u2 = new Dense(4.0, 8.0);

ClassicalSet s1 = new ClassicalSet();
ClassicalSet s2 = new ClassicalSet();

ClassicalSet intersection = s1.intersection(s2);
ClassicalSet union = s2.union(s2);
\end{lstlisting}

\subsection{Funkcje przynależności}
W aplikacji zaimplementowano funkcje przynależności o dwóch kształtach: trójkątną oraz trapezoidalną. Klasy \textbf{Triangular} oraz \textit{Trapezoidal}
dziedziczą po abstrakcyjnej klasie \textbf{MembershipFunction}. Z racji tego iż obliczenia na funkcjach przynależności nie są zależne od ich kształtu,
logika obliczeń zawiera się w abstrakcyjnej klasie \textbf{MembershipFunction}, natomiast dwie wcześniej wspomniane klasy służą jako kontenery dla punktów
funkcji przynależności.

Przykładowo chcąc utworzyć trójkątną funckję przynależności dla kwantyfikatora ,,około połowa'' na przestrzeni rozważań w przedziale [0, 1] można posłużyć
się poniższym fragmentem kodu (punkty funkcji można również zdefiniować od razu w konstruktorze):

\begin{lstlisting}
Triangular membershipFnc = new Triangular();
membershipFnc.setA(new Point(0.25, 0.0));
membershipFnc.setB(new Point(0.50, 1.0));
membershipFnc.setC(new Point(0.75, 0.0));
\end{lstlisting}

W abstrakcyjnej klasie \textbf{MembershipFunction} zaimplementowano publiczną metodę \textbf{y} która oblicza wartość funkcji przynależności dla podanego
parametru wejściowego. Poniżej znajduje się przykład obliczenia wartości funkcji przynależności zdefiniowanej na powyższym fragmencie kodu źródłowego,
dla wartości wejściowych: 0.5, 0.4, 0.3.

\begin{lstlisting}
double a = membershipFnc.y(0.5);
double b = membershipFnc.y(0.4);
double c = membershipFnc.y(0.3);
\end{lstlisting}

Kolejne zmienne będą miały następujące wartości: a = 1.0, b = 0.6, c = 0.19.

\subsection{Zbiory rozmyte}
Klasy reprezentujące zbiory rozmyte zostały umieszczone w pakiecie \textbf{sets}. Wszystkie klasy realizujące zbiory rozmyte implementują interfejs
\textbf{IFuzzySet}.

\begin{itemize}
  \item isEmpty -- metoda powinna zwracać wartość true jeżeli zbiór rozmyty jest pusty.
  \item isConcave -- metoda powinna zwracać wartość true jeżeli zbiór rozmyty jest wklęsły.
  \item isConvex -- metoda powinna zwracać wartość true jeżeli zbiór rozmyty jest wypukły.
  \item isNormal -- metoda powinna zwracać wartość true jeżeli zbiór rozmyty jest normalny.
  \item supp -- metoda powinna zwracać nośnik zbioru rozmytego. Nośnikiem jest obiekt klasy ClassicalSet.
  \item sup -- metoda powinna zwracać supremum zbioru rozmytego.
  \item card -- metoda powinna zwracać liczbę kardynalną zbioru rozmytego.
  \item in -- metoda powinna zwracać wartość stopnia rozmycia zbioru rozmytego.
  \item c -- metoda powinna zwracać wartość centroidu zbioru rozmytego.
  \item hgt -- metoda powinna zwracać wartość wysokości zbioru rozmytego.
  \item core -- metoda powinna zwracać jądro zbioru rozmytego. Jądro jest obiektem klasy ClassicalSet.
  \item alphaCut -- metoda powinna zwracać alfa przekrój zbioru rozmytego. Alfa przekrój jest obiektem klasy ClassicalSet.
  \item union -- metoda ta powinna zwracać nowy zbiór rozmyty który powstanie w wyniku operacji sumy ze zbiorem podanym jako parametr wejściowy.
  \item intersection -- metoda ta powinna zwracać nowy zbiór rozmyty który powstanie w wyniku operacji iloczynu ze zbiorem podanym jako parametr wejściowy.
  \item complement -- metoda ta powinna zwracać nowy zbiór rozmyty który powstanie w wyniku operacji dopełnienia.
\end{itemize}

Interfejs udostępnia jeszcze kilka metod pozwalających na dostęp do obiektu funkcji przynależności, przestrzeni rozważań czy elementów w zbiorze.
Przykładowe użycie klasy reprezentującej zbiór rozmyty typu 1 \textbf{FuzzySetType1} wraz ze szczegółowym opisem znajduje się poniżej.

\begin{lstlisting}
Dense universe = new Dense(1.0, 10.0);
Triangular memFnc = new Triangular(
  new Point(3.0, 0.0), new Point(5.0, 1.0), new Point(7.0, 0.0));
FuzzySetType1 A = new FuzzySetType1();
A.setUniverseOfDiscorse(universe);
A.setMembershipFunction(memFnc);

A.addElement(2.0);
A.addElement(4.0);
A.addElement(5.5);
A.addElement(6.0);
A.addElement(7.0);
  
double in = A.in();
double hgt = A.hgt();
double card = A.card();
A.show();
\end{lstlisting}

W liniach 1 -- 3 tworzona jest gęsta przestrzeń rozważań oraz trójkąta funkcja przynależności. W linii 4 tworzony jest zbiór rozmyty typu 1. Kontruktor nie przyjmuje
żadnych parametrów. W dwóch kolejnych liniach (5 oraz 6) do zbioru wstawiane są wcześniej utworzone obiekty (przestrzeń rozważań oraz funkcja przynależności).
Dodanie elementów do zbioru odbywa się w liniach 8 -- 12. Przykładowe operacje na zbiorze przedstawione są w liniach 14 -- 16. W linii 14 do zmiennej \textbf{in}
zapisana jest wartość stopnia rozmycia tego zbioru, w linii 15 do zmiennej \textbf{hgt} zapisana jest wartość wysokości zbioru natomiast w kolejnej linii do
zmiennej \textbf{card} wartość liczby kardynalnej zbioru. Ostatecznie w linii 17 wywołana jest metoda wyświetlająca na ekranie elementy w zbiorze oraz ich wartości
funkcji przynależności.

Dla powyższego przykładu, zmienne będą miały następujące wartośći: in = 1.75, hgt = 0.6 oraz card = 0.75. W wyniku wywołania metody show, wyświetlone zostaną 
następujące elementy wraz z wartościami funkcji przynależności gdzie pierwszą liczbą jest wartość funkcji przynależności:
\texttt{0/2 0.5/4 0.75/5.5 0.5/6 0/7}.

\subsection{Kwantyfikatory, sumaryzatory oraz kwalifikatory}
Pakiet \textbf{linguistic} przechowuje cztery klasy ściśle związane z samymi podsumowaniami lingwistycznymi. W pakiecie tym znajdują się klasy:
\textbf{Quantifier} reprezentująca kwantyfikator, \textbf{Summarizer} reprezentująca sumaryzator, \textbf{Qualifier} reprezentująca kwalifikator
oraz \textbf{Variable} reprezentująca zmienną lingwistyczną.

\subsubsection{Kwantyfikator}
Klasa \textbf{Quantifier} reprezentująca kwantyfikator jest w zasadzie kontenerem dla zbioru rozmytego reprezentującego kwantyfikator. Dodatkowo można zdefiniować
nazwę dla kwantyfikatora oraz informację o tym czy kwantyfikator jest względny czy bezwzględny. Po wstawieniu do kwantyfikatora zbioru rozmytego, detekcja typu
odbywa się automatycznie na podstawie przestrzeni rozważań tego zbioru. Jeżli przestrzeń jest zbiorem na przedziale [0, 1] wówczas kwantyfikator automatycznie
staje się kwantyfikatorem względnym.

Poniżej przedstawiony został przykładowy fragment kodu który pokazuje w jaki sposób można zdefiniować kwantyfikator.

\begin{lstlisting}
Quantifier q = new Quantifier();
q.setName("Ponad 150");
q.Set(fuzzySet);

double T = q.membershipValue(value);
\end{lstlisting}

Oczywiście konieczne jest wcześniejsze zdefiniowanie zboru rozmytego \textbf{fuzzySet} z funkcją przynalżności o odpowiednim kształcie, aby wyrażenie ,,ponad 150''
było poprawne. Obliczanie wartości funkcji przynależności zbioru rozmytego z kwantyfikatora, odbywa się przez metodę \textbf{membershipValue} gdzie parametrem wejściowym
jest wartość dla której powinna zostać obliczona wartość funkcji przynależności.

\subsubsection{Sumaryzator}
Klasa \textbf{Summarizer} reprezentująca sumaryzator jest w zasadzie kontenerem dla zbioru rozmytego reprezentującego sumaryzator. Dodatkowo można zdefiniować
nazwę dla sumaryzatora oraz nazwę kolumny bazy danych której dotyczy. Zaimplementowano również metodę pozwalającą na wstawienie wszystkich krotek z bazy danych
aby możliwe było wykonanie niezbędnych obliczeń na zbiorach rozmytych.

Poniżej przedstawiony został przykładowy fragment kodu który pokazuje w jaki sosób mozna zdefiniować sumaryzator.

\begin{lstlisting}
Summarizer s = new Summarizer();
s.setName("mlody");
s.setColumn("age");
s.setSet(fuzzySet);
\end{lstlisting}

Podobnie jak w przypadku kwantyfikatora, koniecznie jest wcześniejsze zdefiniowanie zbioru rozmytego \textbf{fuzzySet} który będzie modelował odpowiednią cechę (w tym
przypadku wiek młody). Gdy zbiór rozmyty zostanie zdefiniowany, wówczas możliwe staje się obliczenie wartości sumaryzatora dla krotki z bazy danych. 

\begin{lstlisting}
double a = s.membershipValue(tuple);
\end{lstlisting}

Jeżli kolumna bazy danych nie zostanie zdefiniowana w sumaryzatorze lub zostanie zdefiniowana niepoprawnie, przy próbie obliczenia wartości sumaryzatora dla krotki,
program zgłosi komunikat \texttt{Critical Error! Column definition in Summarizer does not exist in database!}.
Wartość sumaryzatora można obliczyć przez metodę \textbf{membershipValue}.

\begin{lstlisting}
double a = s.putTuples(tuples);
\end{lstlisting}

Aby możliwe było wykonanie obliczeń na zbiorze rozmytym w sumaryzatorze, należy wcześniej wstawić do sumaryzatora pobrane z bazy krotki. Krotki należy wstawić
przez metodę \textbf{putTuples}.

\begin{lstlisting}
double in = s.getFuzzySet().in();
double card = s.getFuzzySet().card();
\end{lstlisting}

Dostęp do obliczeń zbiorów rozmytych w sumaryzatorach odbywa się przez dostęp do obiektu zbioru rozmytego, tak jak pokazano to powyżej.

\subsubsection{Kwalifikator}
Klasa \textbf{Qualifier} reprezentująca kwalifikator jest w zasadzie kontenerem dla zbioru rozmytego reprezentującego kwalifikator. W swojej budowie jest bardzo zbliżona
dla budowy sumaryzatora. Poniższy kod przedstawia sposób tworzenia nowego kwalifikatora.

\begin{lstlisting}
Qualifier w = new Qualifier();
w.setName("niski");
w.setColumn("height");
w.setSet(fuzzySet);
\end{lstlisting}

W tym przypadku należy również pamiętać o wcześniejszym zdefiniowaniu zbioru rozmytego \textbf{fuzzySet}.

Konstruktor klasy \textbf{Qualifier} jest dostępny w dwóch wersjach, konstruktor domyślny (bez parametrów) oraz przeciążony konstruktor który jako parametr wejściowy
przyjmuje obiekt klasy \textbf{Summarizer}.

\begin{lstlisting}
  Qualifier w = new Qualifier(s);
\end{lstlisting}

\subsubsection{Zmienna lingwistyczna}
Klasa \textbf{Variable} reprezentująca zmienną lingwistyczną przechowuje zestaw zbiorów rozmytych modelujących pewną cechę. Zaimplementowano również metody pozwalające
na zdefiniowanie etykiety zmiennej lingwistycznej (\textbf{setName}), przestrzeni rozważań (\textbf{setUniverse}) oraz kolumny z bazy danych której zmienna dotyczy
(\textbf{setColumn}). Dodawanie kolejnych zbiorów rozmytych do zmiennej lingwistycznej odywa się przy pomocy metody \textbf{addFuzzySet}.

Poniżej przedstawiony został przykładowy fragment kodu źródłowego przedstawiający zdefiniowanie przykładowej zmiennej lingwistycznej wraz z opisem.

\begin{lstlisting}
Variable L = new Variable();
L.setName("wiek");
L.setColumn("age");
L.setUniverse(new Dence(1, 100));
L.addFuzzySet("mlody", new FuzzySetType1(), true);
L.addFuzzySet("srednim wieku", new FuzzySetType1(), false);
L.addFuzzySet("stary"), new FuzzySetType1(),true);
\end{lstlisting}

W linii 1 tworzony jest nowy obiekt reprezentujący zmienną lingwistyczną, w liniach 2 -- 4 kolejno dodane są następujące informacje: etykieta zmiennej, nazwa kolumny z bazy
której zmienna dotyczy oraz przestrzeń rozważań. W kolejnych trzech liniach 5 -- 7 wstawiane do zmiennej są zbiory rozmyte.

Metoda \textbf{addFuzzySet} przyjmuje trzy parametry: etykietę dla wstawianej cechy, zbiór rozmyty który będzie tą cechę reprezentował oraz informację o tym, czy dana cech
będzie brać udział w podsumowaniu lingwistycznym. Dla powyższego przykładu, w podsumowaniu będą brały zbiory reprezentujące wiek ,,młody'' oraz ,,stary'', tylko z tych 
zbiorów wygenerowane zostaną sumaryzatory oraz kwalifikatory.

\subsection{Podsumowania}
Podsumowania lingwistyczne reprezentowane są przez osobną klasę: \textbf{Summary} umieszczoną w pakiecie \textbf{summaries}. Klasa ta przechowuje w sobie zestaw sumaryzatorów,
kwalifikatorów oraz kwantyfikator. Słuzy również do obliczenia podsumowania oraz miar jakości tego podsumowania. Zaimplementowano w niej 11 miar jakości podsumowania.
Gdy podsumowanie zostanie przetworzone, a miary jakości tego podsumowania obliczne, wówczas korzystając z metody \textbf{getResults} możliwe jest pobranie obiektu
klasy \textbf{Results} reprezentującej wyniki podsumowania.

Poniżej przedstawiony został sposób stworzenia podsumowania lingwistycznego typu dwa, ze złożonym sumaryzatorem, odpowiadający następującemu wyrażeniu:
$Q$ $P$ będący/mający $W_1$ jest/ma $S_1$ i $S_2$ $[T]$

\begin{lstlisting}
Summary summary = new Summary();
summary.addQuantifier(q);
summary.addSummarizer(s1);
summary.addSummarizer(s2);
summary.addQualifier(w1);
summary.setTuples(tuples);
summary.qualityMeasures();
Results results = summary.getResults();
\end{lstlisting}

Powyższy fragment kodu jest na tyle klarowny iż nie potrzebne jest jego wyjaśnienie, jednak metodą wartą uwagi jest \textbf{setTuples}. Dopóki krotki z bazy danych na których
będą przeprowadzane obliczenia nie zostaną wstawione do podsumowania, podsumowanie nie będzie możliwe do wygenerowania. Należy również pamiętać iż wyniki zostaną wygenerowane
dopiero po wywołaniu metody \textbf{qualityMeasures}. Wcześniejsza próba wywołania metody \textbf{getResults} spowoduje wyświetlenie komunikatu błędu. Jak widać na poniższym
kodzie źródłowym metody \textbf{setTuples}, w trakcie jej wywołania do wszystkich zbiorów rozmytych wstawiane są odpowiednie krotki, aby przy obliczaniu samych miar podsumowania,
możliwe było wywoływanie tylko metod wykonujących obliczenia na tych zbiorach.

\begin{lstlisting}
public void setTuples(List<Map<String, Double>> tuples) {
  this.tuples = tuples;

  for (int i = 0; i < summarizers.size(); ++i) {
	  summarizers.get(i).putTuples(tuples);
  }
  for (int i = 0; i < qualifiers.size(); ++i) {
	  qualifiers.get(i).putTuples(tuples);
  }
}
\end{lstlisting}

W klasie \textbf{Summary} zaimplementowano jedynaśnie metod realizujących obliczenia jedynastu mierników jakości podsumowania. Są to kolejno prywante metody \textbf{T1} do
\textbf{T11} oraz metoda \textbf{T} zwracająca wartość optymalnego podsumowania. Jak już wspomniano dostęp do wyników jakości podsumowania odbywa się przez obiekt klasy
\textbf{Results} który w rzeczywistości jest kontenerem tych miar.

\begin{lstlisting}
public void qualityMeasures() {
  double T1  = T1();
  double T2  = T2();
  ...
  double T11 = T11();
  double T = 0.0;
	
  Results results = new Results(T1, T2, T3, T4, T5, T6, T7, 
         T8, T9, T10, T11, T, generateSummaryText());
  this.results = results;
}
\end{lstlisting}

Metoda \textbf{generateSummaryText} tworzy komunikat z podanych do podsumowania sumaryzatorów, kwalifikatorów oraz kwantyfikatora. Tak więc w obiekcie klasy \textbf{Results}
są nie tylko miary, lecz również wygenerowany komunikat. Taki komunikat można wyświetlić na okranie lub zapisać do pliku.

\subsection{Generator podsumowań}
Klasa \textbf{Generator} umieszczona w pakiecie \textbf{utils} jest istotnym elementem całej aplikacji. Jej głównym zadaniem jest generowanie podsumowań na podstawie dostarczonych
do niej zmiennych lingwistycznych oraz kwantyfikatorów. Podsumowania generowane są zgodnie ze wzorem~\ref{wzor_generatora_podsumowan}. Gdy podsumowania zostaną wygenerowane
możliwe jest pobranie listy podsumowań które dla których następnie będzie mozna obliczyć mierniki jakości tych podsumowań.

Przykładowy fragment kodu źródłowego prezentujący sposób użycia tej klasy został zamieszczony poniżej.

\begin{lstlisting}
Generator generator = new Generator();
generator.addQuantifier(q1);
generator.addQuantifier(q2);
generator.addVariable(L1);
generator.generate();
List<Summary> summaries = generator.getSummaries();
\end{lstlisting}

Jak widać do obiektu klasy \textbf{Generator} należy dostarczyć kwantyfikatory oraz zmienne lingwistyczne na których będą generowane podsumowania. Należy pamiętać, aby
część zbiorów rozmytych w zmiennej lingwystycznej miała status aktywności ustawiony na wartość true, w przeciwnym razie nie powstaną podsumowania. Zadaniem generatora jest
jedynie połączenie zbioru kwantyfikatorów oraz elementów zmiennych lingwistycznych we wszystkie możliwe kombinacje. Gdy to nastąpi możliwe jest pobranie listy podsumowań
metodą \textbf{getSummaries}.

Należy pamiętać iż generator nie wykonuje żadnych obliczeń na podsumowaniach, przygotowuje jedynie ich listę. Aby obliczyć jakości wygenerowanych podsumowań, można posłużyć
się poniższym fragmentem programu.

\begin{lstlisting}
List<Results> results = new ArrayList<>();
for (Summary summary : sumamries) {
  summary.setTuples(tuples);
  summary.qualityMeasures();
  results.add(summary.getResults());
}
\end{lstlisting}

Tym sposobem w zmiennej \textbf{results} będą znajdować się wszystkie mierniki jakości podsumowań oraz ich komunikaty. Takie komunikaty można albo od razu wyświetlić na ekranie,
albo zapisać je do pliku:

\begin{lstlisting}
  summary.show();
  summary.appendToFile('podsumowania.txt');
\end{lstlisting}

\subsection{Pozostałe klasy}

\subsubsection{Konstruktor obiektów}
Klasa \textbf{ObjectConstructor} z pakietu \textbf{app} jest klasą której wszystkie metody są statyczne. Klasa ta służy do budowania obiektów wykorzystywanych w aplikacji.
Klasa ta pozwala na tworzenie następujących obiektów: kwantyfikatorów, kwalifikatorów, sumaryzatorów, zmiennych lingwistycznych, funkcji przynależności, zbiorów rozmytych,
punktów oraz przestrzeni rozważań. Takie rozwiązanie pozwala na zachowanie większej czytelności kodu aplikacji oraz ogranicza ilość zmiennych pośrednich które potrzebne są 
do tworzenia bardziej złożonych obiektów.

Poniżej przedstawiony został przykład utworzenia kwantyfikatora w klasyczny sposób, tworząc w pierwszej kolejności przestrzeń rozważań, następnie funkcję przynależności, 
zbiór rozmyty oraz ostatecznie kwantyfikator.

\begin{lstlisting}
Dense universe = new Dense(0, 20000);

Triangular triangular = new Triangular();
triangular.setA(new Point(2800.0, 0.0));
triangular.setB(new Point(3000.0, 1.0));
triangular.setC(new Point(3200.0, 0.0));

FuzzySetType1 set = new FuzzySetType1();
set.setUniverseOfDiscorse(universe);
set.setMembershipFunction(triangular);

Quantifier q = new Quantifier();
q.setFuzzySet(set);
q.setName("Okolo 3000");
\end{lstlisting}

Dla porównania, poniżej przedstawiony został sposób generowania kwantyfikatora przy pomocy statycznej metody \textbf{createQuantifier} klasy \textbf{ObjectConstructor}.
Jak widać nie ma w takim przypadku potrzeby tworzenia zmiennych pośrednich, a tworzenie tego złożonego obiektu można ograniczyć do jednej linijki. 

\begin{lstlisting}
Quantifier q = ObjectContructor.createQuantifier(
    "okolo 3000",
    IFuzzySet.Type.TYPE1,
    MembershipFunction.Type.TRIANGULAR,
    ObjectContructor.createPoints3(
        2800.0, 0.0,
        3000.0, 1.0,
        3200.0, 0.0),
    IUniverseOfDiscourse.Type.DENSE,
    ObjectContructor.createDenseUniverseBoundary(0, 20000));
\end{lstlisting}

Metoda na wejściu przyjmuje wszystkie niezbędne obiekty do budowy kwantyfikatora. Parametrami wejściowymi metody są kolejno: nazwa kwantyfikatora, typ zbioru rozmytego,
kształt funkcji przynależności, lista punktów definiujących funkcję przynależności (listę tą również można tworzyć przy użyciu statycznej metody klasy \textbf{ObjectConstructor}),
typ przestrzeni rozważań oraz listę elementów lub przedział zbioru rozmytego.

W identyczny sposób można tworzyć pozostałe obiekty. Metody klasy \textbf{ObjectConstructor} używane są w trakcie budowania obiektów zdefiniowanych w pliku generowanym
przez graficzny interfejs użytkownika niniejszej aplikacji.

\subsubsection{Baza danych}
Klasa \textbf{Database} umieszczona w pakiecie \textbf{app} służy do pobierania krotek z bazy danych. Posiada domyślny kontruktor oraz cztery publiczne metody.
Przed nawiązaniem połączenia z bazą, należy zdefiniować plik w którym znajduje się baza SQLITE, służy do tego metoda \textbf{setDatabaseFile}. Gdy ścieżka
do pliku bazy zostanie zdefiniowana, możliwe jest nawiązanie połączenia z bazą przez metodę \textbf{connect}.
Pobieranie krotek z bazy możliwe jest przez wywołanie metody publicznej \textbf{getAllTuples} gdzie parametrem wejściowym jest nazwa tabeli z baz danych. Na wyjściu tej metody
znajduje się lista wszystkich krotek z bazy, ale z ograniczoną ilością kolumn. Zwracane są tylko te kolumny, w których wartości są liczbowe pozostałe są pomijane.

Poniżej przedstawiony został sposób użycia klasy \textbf{Database}.

\begin{lstlisting}
Class.forName("org.sqlite.JDBC");
...
Database db = new Database();
db.setDatabaseFile('/db/nba.sqlite3');
db.connect();

List<Map<String, Double>> tuples = db.getAllTuples("games");
\end{lstlisting}

Linia 1 jest bardzo istotna, jeżli nie metoda \textbf{forName} nie zostanie wywołana, nie będzie dostępu do klas realizujących obsługę bazy danych.

Należy jeszcze dodać iż zwracane dane są listą mapy, typ jest następujący: \texttt{List<Map<String, Double>>} gdzie wartością tekstową jest nazwa kolumny dla i-tej krotki,
a wartością liczbową wartość i-tej krotki w danej kolumnie.
W taki właśnie sposób klasy zbiorów rozmytych odczytują odpowiednią wartość liczbową z krotki.

\subsubsection{Punkt}
Klasa \textbf{Point} umieszczona w pakiecie \textbf{utils} wykorzystywana jest głównie przez klasy reprezentujące funkcje przynależności. Posiada jedynie pola reprezentujące
pozycję punktu w przestrzeni dwuwymiarowej. Zaimplementowana jest również metoda \textbf{toString} aby ułatwić wyświetlanie współrzędnych punktu.

Przykładowy sposób użycia klasy został zamieszczony poniżej.

\begin{lstlisting}
Point p = new Point(0.2, 0.5);
System.out.println("Punkt p = " + p);
\end{lstlisting}

\subsubsection{Para}
Klasa \textbf{Pair} umieszczona w pakiecie \textbf{utils} jest obiektem wzorowanym na klasie QPair\footnote{http://doc.qt.digia.com/qt/qpair.html} z biblioteki QT. Celem klasy
jest przechowywanie pary elementów niezależnie od ich typów. W klasie \textbf{Pair} typy pary są generyczne. Klasa posiada dwa pola: first oraz secound oraz 3 funkcje dostępowe.
Istnieją dwa konstruktory: domyślny oraz konstruktor z wartościami początkowymi pól first oraz secound. Podobnie jak w przypadku klasy \textbf{Point} w tej również przygotowana
została metoda \textbf{toString} aby ułatwić wyświetlanie zawartości obiektów tej klasy.

Przykładowy sposób użycia klasy został zamieszczony poniżej.

\begin{lstlisting}
Pair<String, Double> pair = new Pair<>();
pair.set("Tekst", 1.0);
System.out.println(pair);
\end{lstlisting}





\section{Graficzny interfejs użytkownika}
Główne okno programu zostało przedstawione na rysunku \ref{fig1}. Składa się ono z paska menu, w którym istnieje możliwość przejść do opcji zaawansowanych, z pola roboczego zbudowanego z 3 paneli oraz przycisku generującego podsumowanie.

\begin{figure}[ht]
    \centering
      \includegraphics[width=0.7\textwidth]{images/mainGui.png}
    \caption{Okno główne.}
    \label{fig1}
\end{figure}

\subsection{Generowanie podsumowania}
W oknie głównym znajdują sie 3 panele:
\begin{itemize}
  \item ilość - zawierajacy kwantyfikatory,
  \item zbiór cech - zawierający zmienne lingwistyczne,
  \item cechy - zawierajacy cechy aktualnie zaznaczonej zmiennej lingwistycznej z panelu zbiór cech.
\end{itemize}
Panel \textit{Cechy} po uruchomieniu aplikacji jest pusty. Zostanie on uzupełniony w momencie wybrania elementu z panelu \textit{Zbiór cech}. Z paneli wybieramy opcje dla których będą generowane podsumowania, a następnie naciskamy na przycisk \textit{Generuj}.
Po wykonaniu obliczeń pojawia się nowe okno (rysunek \ref{fig2}) z tabelą zawierającą treść podsumowania wraz z jej miarami. W oknie mamy możliwość wyboru podsumowań oraz zapisu ich do pliku.

\begin{figure}[ht]
    \centering
      \includegraphics[width=0.9\textwidth]{images/summary.png}
    \caption{Okno wygenerowanego podsumowania.}
    \label{fig2}
\end{figure}


\subsection{Opcje zaawansowane}
Opcje zaawansowane umożliwiają definiowanie, modyfikowanie oraz usuwanie kwantyfikatorów, cech i zmiennych lingwistycznych.

\subsubsection{Kwantyfikatory}
\begin{figure}[ht]
    \centering
      \includegraphics[width=0.5\textwidth]{images/kwantyfikatory.png}
    \caption{Okno definiowania kwantyfikatorów.}
    \label{fig3}
\end{figure}
Okno kwantyfikatory (rysunek \ref{fig3}) składa się z:
\begin{itemize}
  \item listy rozwijanej zawierającej nazwy kwantyfikatorów,
  \item przycisku dodającego nową nazwę kwantyfikatora,
  \item przycisku usuwającego aktualnie zaznaczonego kwantyfikatora,
  \item przycisku definującego przestrzeń rozważań
  \item przycisku definującego funkcje przynależności
  \item przycisku zapisującego nowy kwantyfikator bądź aktualizujący modyfikacje kwantyfikatora
\end{itemize}

Tworzenie nowego kwantyfikatora odbywa się w następujący sposób:
\begin{enumerate}
  \item utworzenie nowej nazwy kwantyfikatora - przycisk \textit{Nowy},
  \item wybranie z rozwijanej listy nowego kwantyfikatora,
  \item określenie typu oraz zdefiniowanie przestrzeni rozważań,
  \item określenie typu oraz zdefiniowanie funkcji przynależności,
  \item zatwierdzenie wartości - przycisk \textit{Zapisz}.
\end{enumerate}

Usuwanie kwantyfikatora odbywa się poprzez wybranie kwantyfikatora, a następnie naciśnięcia przycisku usuń.

Modyfikacja kwantyfikatora odbywa się w analogiczny sposób co tworzenie nowego kwantyfikatora za wyjątkiem definiowania jego nazwy.

\subsubsection{Cechy}
Okno \textit{cechy} (rysunek \ref{fig4}) jest rozszerzeniem okna \textit{kwantyfikatory}. Poza polami znajdującymi się w oknie kwantyfikatorów zawiera rozwijalną listę nazw atrybutów tabeli. Procec dodawania/edytowania/usuwania jest analogiczny do tych samych procesów co w kwantyfikatorach.

\begin{figure}[ht]
    \centering
      \includegraphics[width=0.5\textwidth]{images/cechy.png}
    \caption{Okno definiowania cech.}
    \label{fig4}
\end{figure}

\subsubsection{Zmienna lingwistyczna}
\begin{figure}[ht]
    \centering
      \includegraphics[width=0.5\textwidth]{images/zmiennaLingwistyczna.png}
    \caption{Okno definiowania zmiennej lingwistycznej.}
    \label{fig5}
\end{figure}
Okno zmiennej lingwistycznej (rysunek \ref{fig5}) składa się z:
\begin{itemize}
  \item listy rozwijanej zawierającej nazwy zmiennych lingwistycznych,
  \item przycisku dodającego nową nazwę zmiennej lingwistycznej,
  \item przycisku usuwającego aktualnie zaznaczonej zmiennej lingwistycznej,
  \item przycisku definującego przestrzeń rozważań,
  \item panelu zawierającego cechy wcześniej zdefiniowane,
  \item przycisku zapisującego nową zmienną lingwistyczną bądź aktualizujący modyfikacje zmiennej lingwistycznej.
\end{itemize}

Tworzenie nowej zmiennej lingwistycznej odbywa się poprzez: zdefiniowania nowej nazwy zmiennej (przycisk \textit{Nowa}), określenia typu przestrzeni rozważań oraz jej zdefiniowania, wybraniu z cech i zakończenia procesu przez naciśnięcie przycisku \textit{Zapisz}.

\subsection{Pliki konfiguracyjne}
Jedną z cech aplikacji jest możliwość ,,zapamiętywania'' wcześniej zdefiniowanych parametrów. Parametry (kwantyfikatory, cechy, zmienna lingwistyczna) zapisywane są do odpowiednich plików konfiguracyjnych w formacie xml. 

\begin{lstlisting}
<schema>
  <Features typeUniverse="gesta" typeMembership="trojkatna">
    <Name>grano krotko</Name>
    <UniverseOfDiscourse>0;60</UniverseOfDiscourse>
    <PointsOfMebershipFunction>1.0;1.0 8.0;1.0 10.0;0.0</PointsOfMebershipFunction>
    <Column>min</Column>
  </Features>
  <Features typeUniverse="gesta" typeMembership="trojkatna">
    <Name>nie grano wcale</Name>
    <UniverseOfDiscourse>0;60</UniverseOfDiscourse>
    <PointsOfMebershipFunction>0.0;1.0 1.0;0.0 60.0;0.0</PointsOfMebershipFunction>
    <Column>min</Column>
  </Features>
</schema>
\end{lstlisting}

Powyższy listing prezentuje jeden z 3 plików konfiguracyjnych. Jest on przykładem przechowywania cech w pliku xml. Obiekty w pozostałych przypadkach przechowywane są w podobny sposób. Należy nadmienić, że plik konfiguracyjny zmiennych lingwistycznych jest zależny od pliku konfiguracyjnego cech, gdyż zawiera on w tagach \textit{Features} odwołania do cech.





\section{Materiały i metody}

\subsection{Obiekty biorące udział w podsumowaniach}
Aplikacja pozwala na dodawanie, modyfikowanie oraz edytowanie wszystkich elementów biorących udział w podsumowaniach. Użytkownik może zdefiniować własne kwantyfikatory oraz
zmienne lingwistyczne które będą brały udział w podsumowaniach. Wstępnie przygotowany został pewien zbiór kwantyfikatorów oraz zmiennych lingwistycznych które zostały przedstawione
poniżej.

\subsubsection{Kwantyfikatory}
Domyślnie zdefiniowano łącznie 8 kwantyfikatorów, cztery względne oraz cztery bezwzględne:

\paragraph{Względne}
-- których przestrzeń rozważań jest w przedziale [0, 1].

Zdefiniowane zostały cztery następujące kwantyfikatory: prawie wszyscy, połowa, mniej niż 1/4 oraz ponad 3/4.

\includegraphics[width=120mm]{images/drawQuan2.png}
\paragraph{Bezwzględne}
-- których przestrzeń rozważań jest w przedziale [0, 20000].

Zdefiniowane zostały cztery następujące kwantyfikatory: około 3000, około 6000, około 8000 oraz ponad 100.

\includegraphics[width=120mm]{images/drawQuan1.png}

\subsubsection{Zmienne lingwistyczne}
Domyślnie zdefiniowano siedem zmiennych linwistycznych, które zostały opisane poniżej:

\paragraph{Czas gry} 
-- związana jest z czasem (liczbą minut) który zawodnik spędził na parkiecie w trakcie meczu. \\
Zmienna dotyczy tabeli: \textbf{min} \\
Przestrzeń rozważań: \textbf{gęsta}, przedział \textbf{[0.0, 60.0]} \\
Liczba zbiorów rozmytych: \textbf{6} \\
Cechy: \textbf{nie grano wcale, grano krótko, grano długo, grano w dogrywce, grano przez cały mecz, grano około 30 minut}
Minimalna oraz maksymalna wartość w bazie: \textbf{[0, 57]}

\includegraphics[width=120mm]{images/drawLang1.png}

\paragraph{Skuteczność w rzutach}
-- związana jest z procentowym stosunkiem prób do udanych rzutów. \\
Zmienna dotyczy tabeli: \textbf{fgp} \\
Przestrzeń rozważań: \textbf{gęsta}, przedział \textbf{[0.0, 1.0]} \\
Liczba zbiorów rozmytych: \textbf{3} \\
Cechy: \textbf{niska skuteczność, duża skuteczność, przeciętna skuteczność}
Minimalna oraz maksymalna wartość w bazie: \textbf{[0, 1]}

\includegraphics[width=120mm]{images/drawLang2.png}

\paragraph{Skuteczność w rzutach za 3 punkty}
-- związana jest z procentowym stosunkiem prób do udanych rzutów za 3 punkty. \\
Zmienna dotyczy tabeli: \textbf{3pp} \\
Przestrzeń rozważań: \textbf{gęsta}, przedział \textbf{[0.0, 1.0]} \\
Liczba zbiorów rozmytych: \textbf{3} \\
Cechy: \textbf{niska skuteczność, duża skuteczność, przeciętna skuteczność}
Minimalna oraz maksymalna wartość w bazie: \textbf{[0, 1]}

\includegraphics[width=120mm]{images/drawLang3.png}

\paragraph{Skuteczność w rzutach osobistych}
-- związana jest z procentowym stosunkiem prób do udanych rzutów osobistych. \\
Zmienna dotyczy tabeli: \textbf{ftp} \\
Przestrzeń rozważań: \textbf{gęsta}, przedział \textbf{[0.0, 1.0]} \\
Liczba zbiorów rozmytych: \textbf{3} \\
Cechy: \textbf{niska skuteczność, duża skuteczność, przeciętna skuteczność}
Minimalna oraz maksymalna wartość w bazie: \textbf{[0, 1]}

\includegraphics[width=120mm]{images/drawLang4.png}

\paragraph{Brutalność gry zawodnika}
-- związana jest z liczbą fauli popełnionych przez zawodnika w trakcie meczu. \\
Zmienna dotyczy tabeli: \textbf{pf} \\
Przestrzeń rozważań: \textbf{gęsta}, przedział \textbf{[0.0, 10.0]} \\
Liczba zbiorów rozmytych: \textbf{2} \\
Cechy: \textbf{grał agresywnie, grał spokojnie}
Minimalna oraz maksymalna wartość w bazie: \textbf{[0, 6]}

\includegraphics[width=120mm]{images/drawLang5.png}

\paragraph{Wsparcie w zdobyciu punktów}
-- związana jest z liczbą asyst wykonanych przez zawodnika w trakcie meczu. \\
Zmienna dotyczy tabeli: \textbf{ast} \\
Przestrzeń rozważań: \textbf{gęsta}, przedział \textbf{[0.0, 25.0]} \\
Liczba zbiorów rozmytych: \textbf{3} \\
Cechy: \textbf{grał dobry asystent, grał przeciętny asystent, grał przypadkowy asystent}
Minimalna oraz maksymalna wartość w bazie: \textbf{[0, 6]}

\includegraphics[width=120mm]{images/drawLang6.png}
\paragraph{Ilość zdobytych punktów}
-- związana jest z liczbą zdobytych punktów przez zawodnika w trakcie meczu. \\
Zmienna dotyczy tabeli: \textbf{pts} \\
Przestrzeń rozważań: \textbf{gęsta}, przedział \textbf{[0.0, 51.0]} \\
Liczba zbiorów rozmytych: \textbf{3} \\
Cechy: \textbf{zdobyto mało punktów, zdobyto dużo punktów, zdobyto około 25 punktów}
Minimalna oraz maksymalna wartość w bazie: \textbf{[0, 51]}

\includegraphics[width=120mm]{images/drawLang7.png}


\section{Wyniki}

\subsection{Podsumowania pierwszego typu z prostym sumaryzatorem}
\begin{verbatim}
W około 6000 meczach jest/ma grano krótko [0.315]
W około 6000 meczach jest/ma grał przypadkowy asystent [0.983]
W ponad 100 meczach jest/ma grano krótko [0.686]
W ponad 100 meczach jest/ma przeciętna skuteczność [0.935]
W ponad 100 meczach jest/ma grał spokojnie [0.523]
W ponad 100 meczach jest/ma zdobto mało punktów [0.311]
W mniej niż 1/4 meczach jest/ma grano przez cały mecz [0.621]
W mniej niż 1/4 meczach jest/ma zdobyto dużo punktów [0.978]
W mniej niż 1/4 meczach jest/ma grał agresywnie [0.614]
\end{verbatim}

\subsection{Podsumowania pierwszego typu ze złożonym sumaryzatorem}
\begin{verbatim}
W około 6000 meczach jest/ma grano krótko i grał spokojnie [0.782]
W około 6000 meczach jest/ma grano krótko i zdobto mało punktów [0.472]
W około 6000 meczach jest/ma grano krótko i grał spokojnie i zdobyto mało
punktów [0.709]
W około 8000 meczach jest/ma grał spokojnie i zdobto mało punktów [0.661]
W ponad 100 meczach jest/ma grano krótko i grał spokojnie [0.709]
W ponad 100 meczach jest/ma przeciętna skuteczność i grał spokojnie [0.984]
W ponad 100 meczach jest/ma przeciętna skuteczność i zdobto mało punktów [0.954]
W ponad 100 meczach jest/ma grał spokojnie i zdobto mało punktów [0.594]
W ponad 100 meczach jest/ma grano przez cały mecz i grał agresywnie [0.993]
W ponad 100 meczach jest/ma przeciętna skuteczność i grał spokojnie i zdobto
mało punktów [0.988]
W mniej niż 1/4 meczach jest/ma grano przez cały mecz i zdobyto dużo
punktów [0.986]
\end{verbatim}
\subsection{Podsumowania drugiego typu}
\begin{verbatim}
W prawie wszystkie meczach będący/mający grano krótko jest/ma grał
spokojnie [0.576]
W prawie wszystkie meczach będący/mający grano krótko jest/ma zdobto mało
punktów [1.000]
W prawie wszystkie meczach będący/mający grano krótko jest/ma grał spokojnie
i zdobto mało punktów [0.461]
W mniej niż 1/4 meczach będący/mający grano przez cały mecz jest/ma zdobyto
dużo punktów [0.819]
W połowie meczach będący/mający grał agresywnie jest/ma grał przypadkowy
asystent [0.367]
W mniej niż 1/4 meczach będący/mający grał przypadkowy asystent jest/ma grał
agresywnie [0.307]
\end{verbatim}

\section{Dyskusja}
W trakcie tworzenia aplikacji, konieczne było rozwiązanie wielu znaczących problemów, począwszy od znalezienia odpowiedniej bazy danych, przez rozwiązanie 
problemu przechowywania informacji o przestrzeniach rozważań aż po błędy które wynikały z obliczeń na liczbach zmiennoprzecinkowych. Bardziej znaczące problemy
zostały przedstawione poniżej.

Pierwszym znaczącym problemem przy realizacji zadania, było odszukanie stosownej bazy danych która spełniałaby założenia umieszczone w treści niniejszego zadania.
Konieczne było znalezienie bazy, która posiadałaby co najmniej 10 tysięcy rekordów, oraz co najmniej 10 kolumn z danymi które można podsumowywać lingwistycznie
(kolumny z danymi numerycznymi). W trakcie poszukiwań, jedyne sensowne bazy które dało się znaleźć związane były z informacjami o galaktykach. Spełniały zarówno
warunek ilościowy danych (rekordów było zdecydowanie więcej niż 10 tysięcy) oraz jakościowy (Co najmniej 10 kolumn posiadało wartości numeryczne). Jednak dane te 
najczęściej związane były z różnymi współrzędnymi pozwalającymi odnaleźć galaktykę na nocnym niebie.

Ostatecznie postanowiono przygotować własną bazę danych na podstawie informacji dostępnych w internecie. Wybór padł na wyniki meczów koszykówki NBA. W zasadzie
wybór nie był przypadkowy, gdyż na amerykańskich stronach sportowych, dostępnych jest sporo statyskyk związanych z każdym meczem NBA. Za zródło informacji posłużyła
strona internetowa \url{http://espn.go.com/nba/}. Niestety witryna ta, nie pozwala w sposób bezpośredni na pobranie tych wszystkich informacji, dlatego też
przygotowany został specjalny parser który analizował witrynę w celu poszukiwania statystyk o meczach. Poszukiwania rozpoczynały się od witryny 
\url{http://espn.go.com/nba/players} na której parser poszukiwał odnosników do spisu zawodników danej drużyny, następnie poszukiwany był odnośnik do witryny z danymi
zawodnika.

\includegraphics[width=120mm]{images/game_log.png}

Na witrynie poświęconej każdemu zawodnikowi z osobna, znajduje się tabela \textbf{GAME LOG} a w niej statystyki z kolejnych meczy w danym sezonie. To właśnie dane
z tych tabel stały się bazą danych biorącą udział w podsumowaniach. Parser przeanalizował witrynę każdego zawodnika na którą trafił przeglądając rekurencyjnie odnośniki
od strony startowej i zapisywał zawartość tabel do bazy danych. W taki sposób udało się zgromadzić ponad 23 tysiące rekordów.

Kolejnym istotnem problemem który pojawił się w zasadzie pod koniec realizacji aplikacji, było zdefiniowanie odpowiednich zbiorów rozmytych modelujących założone cechy.
Aby prawidłowo dobrać przestrzenie rozważań dla analizowanych cech (kolumn z tabeli bazy danych) oraz kształty i punkty funkcji przynależności, należało w pierwszej
kolejności dokładnie przeanalizować bazę danych. Nie śledząć na bierząco rozgrywek NBA ciężko było stwierdzić czy więszkość zawodników gra agresywnie, jest skuteczna
w ataku czy może zdobywa dużo bądź mało punktów w trakcie meczu. Dopiero analiza zebranych danych pozwoliła na dobranie odpowiednich wartości.

Bardzo użytecznym rozwiązaniem okazało się przygotowanie klasy która przechowuje w swoim ciele statyczne metody pozwalające na budowanie złożonych obiektów jak: funkcje
przynależności, zbiory rozmyte, sumaryzatory, kwantyfikatory czy zmienne lingwistyczne. Przygotowanie zestawu metod tworzących takie obiekty pozwoliła na zachowanie
względnego porządku w kodzie oraz przejrzystości kodu. Pomogło również wyeliminować tworzenie zbędnych zmiennych w głównej metodzie aplikacji. (Nie ma konieczności wielokrotnego
definiowania obiektów przestrzeni rozważań, czy funkcji przynależności).

Pojawiły się również pewne problemy związane z przechowywaniem przedziału obiektu gęstej przestrzeni rozważań oraz wykonywania operacji na takiej przestrzeni.
Z racji tego iż wszystkie obliczenia wykonywane są numerycznie, gęsta przestrzeń rozważań traktowana jest w aplikacji jako dyskretna przestrzeń rozważań której elementy
przedziału zapisane są jago gęste punkty. Tak więc definiując gęstą przestrzeń rozważań z przedziałem [0, 1] w rzeczywistości tworzona jest dyskretna przestrzeń rozważań
z elementami 0.000, 0.001, 0.002, ..., 0.999, 1.000 (w zależności od zdefiniowanego w konfiguracji kroku).

Kolejny problem który należało rozwiązać, a jest ściśle związany z poprzednim jest pewna niedokładność obliczeń na liczbach zmiennoprzecinkowych. Tworząc dyskretną przestrzeń
rozważań w oparciu o przedział gęstej powstawały następujące niedokładności, wartość \textbf{59.80000000000058} zamiast \textbf{59.8}. Oryginalny kod tworzący przestrzeń
wraz z poprawką znajduje się poniżej.

\begin{lstlisting}
public void addInterval(double min, double max) {
	DecimalFormat format = new DecimalFormat("#.####");  // BUGFIX
	for (double i = min; i <= max; i += step) {
		//elements.add(i);	// BUG HERE
		elements.add(Double.valueOf(format.format(i)));    // BUGFIX
	}
	
	minBoundary = min;
	maxBoundary = max;
}
\end{lstlisting}

Jak widać powyżej, niezbędne okazało się obliczanie zaokrągleń.

Ostatnim większym problemem o którym warto wspomnieć jest związany z optymalizacją aplikacji. Przy kilkukrotnym uruchomieniu aplikacji, okazało się iż zbyt duża ilość wybranych
cech które powinny brać udział w podsumowaniach powoduje wyczerpanie całej dostępnej pamięci operacyjnej oraz zgłoszenie błędu: \texttt{Exception in thread "main" java.lang.OutOfMemoryError: GC overhead limit exceeded}. Być może problem ten można rozwiązać, projektując w inny sposób generator podsumowań zaimplementowany w niniejszej
aplikacji.

\section{Wnioski}
Najważniejszym wnioskiem który nasuwa się po realizacji niniejszej aplikacji jest konieczność posiadania wiedzy eksperckiej która pozwali na przygotowanie odpowiednich modeli
cech które będą podsumowywane. Bez takiej wiedzy podsumowania stają się mało wiarygodne. Trudność zadania nie ogranicza się jedynie do przygotowania logiki aplikacji, 
dużym wyzwaniem jest również zdefiniowanie kwantyfikatorów oraz w głównej mierze sumaryzatorów i kwalifikatorów. Bez eksperckiej wiedzy której zabrakło w trakcie realizacji
zadania, konieczna była szczegółowa analiza bazy danych, aby na jej podstawie możliwe było zdefiniowanie przykładowych cech które przyszły użytkownik będzie mógł podsumowywać.


\begin{thebibliography}{0}
\bibitem{niwiadom}
  Adam Niewiadomski,
  \emph{Methods for the Linguistic Summarization of Data: Applications of Fuzzy Sets and Their Extensions}.
  Akademicka Oficyna Wydawnicza EXIT, Warszawa 2008.
\bibitem{Akay}
  Diyar Akay, Osman Kulak, Brian Henson,
  \emph{Conceptual design evaluation using interval type-2 fuzzy information axiom},
  2010 Elsevier B.V.
\bibitem{Kumbasar}
  Tufan Kumbasar, Ibrahim Eksin, Mujde Guzelkaya, Engin Yesil,
  \emph{Interval type-2 fuzzy inverse controller design in nonlinear IMC structure},
  2011 Elsevier Ltd.
\bibitem{Bezdek}
  J.C. Bezdek,
  \emph{Editorial: Fuzzy Models - What Are They, and Why?},
  IEEE Transactions on Fuzzy Systems, Vol. 1, No. 1, February 1993.
\bibitem{Rutkowski}
  L. Rutkowski,
  \emph{<etody i techniki sztucznej inteligencji},
  Wydawnictwo Naukowe PWN, Warszawa 2005.


%\bibitem{lamport94}
%  P.A. Devijver, J. Kittler,
%  \emph{Pattern Recognition teory and  Applications}.
%  Springer-Verlag, belgium, 1986.
\end{thebibliography}


\newpage
\textbf{Klasy przestrzeni rozważań}
\newline
\includegraphics[width=160mm,angle=90]{images/uml_universe.png}

\newpage
\textbf{Klasy funkcji przynależności}
\newline
\includegraphics[width=130mm]{images/uml_membership.png}

\newpage
\textbf{Klasy zbiorów}
\newline
\includegraphics[width=200mm,angle=90]{images/uml_sets.png}

\newpage
\textbf{Klasy podsumowań lingwistycznych}
\newline
\includegraphics[width=175mm,angle=90]{images/uml_linguistics.png}

\newpage
\textbf{Klasy z pakietu tools}
\newline
\includegraphics[width=120mm]{images/uml_tools.png}



\end{document}
